home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / grafix / tools / xanim / xanimamigabeta7 / amiga.c next >
C/C++ Source or Header  |  1995-05-01  |  5KB  |  180 lines
  1. /* This function writes the chunky pixels to the screen.
  2.    In Amiga mode it calls WritePixelArray8() or WriteChunkyPixels()
  3.    when 3.1 is detected. A special fast c2p version will be included
  4.    later.
  5.    In Merlin mode it will write the chunkypixels directly to the screen,
  6.    same for Picasso, EGS and Retina, if I get the source for it.
  7.    Please if you know how to program your gfxcard, try to replace the Merlin
  8.    functions the card specific ones.
  9.    I tried this pure from the autodocs I have and had little possibilities
  10.    to really test it so if it breaks and you know why, please let me know!
  11. */
  12.  
  13. /***********************************************************/
  14. extern LONG gfxcard;
  15. /***********************************************************/
  16.  
  17.  
  18. XPutImage(
  19.     Display*        display,
  20.     Drawable        d,
  21.     GC                gc,
  22.     XImage*            image,
  23.     int                src_x,
  24.     int                src_y,
  25.     int                dest_x,
  26.     int                dest_y,
  27.     unsigned int    width,
  28.     unsigned int    height       )
  29. {
  30. extern struct HRHandle *hrh;
  31. extern UBYTE  *basemem,*memstart;
  32. extern char *im_buff0,*im_buff1;
  33.  
  34. /* oli start */
  35.   extern struct E_EScreen  *pEgsScreen;
  36.   struct E_EBitMap         *pTempBitmap;
  37. /* oli end */
  38.  
  39. /* screen is opened in the other module */
  40. extern Screen *picasso_scr;
  41. extern UBYTE *picasso_mem;
  42.  
  43.     struct IntuiMessage    *imsg;
  44.     struct BitMap tempbm;
  45.     struct VilCopyRecord blitrec;
  46.  
  47.     ULONG                class;
  48.     static long frame = 0;
  49.     static char framename[ 256 ];
  50.  
  51.     if( image->depth == 1 )
  52.     {
  53.         /* B&W Bitmap (1 Bit = 1 Pixel) */
  54.         
  55.         /* erst ins ChipMem kopieren */
  56.         CopyMem( image->data, bwbm->Planes[0], bwbm->BytesPerRow * bwbm->Rows );
  57.         
  58.         /* und dann anzeigen */
  59.         BltBitMapRastPort( bwbm, 0, 0, rp, offx, offy, width, height, 0x030 );
  60.     }
  61.     else if( image->depth == 8 )
  62.     {
  63.         /* Standard 8 Bit Bitmap (chunky pixels) */
  64.         switch (gfxcard)
  65.         {
  66.             case AMIGA:
  67.                  if(GfxBase->LibNode.lib_Version>39)
  68.                     WriteChunkyPixels( rp, offx, offy, offx+width-1, offy+height-1, image->data, width );
  69.                 else
  70.                 {
  71.                     CopyMemQuick(image->data,im_buff1,width*height);
  72.                     WritePixelArray8(rp, offx, offy, offx+width-1, offy+height-1, im_buff1, temprp);
  73.                 }
  74.                 break;
  75.             case MERLIN:
  76.                 hrWriteRectPK8(&hrh->BitMap,image->data,0,0,width,height,1,width); /*MERLIN*/
  77.                 break;
  78.             case EGS:
  79. fprintf(stderr,"Going to blit imagedata to EGS\n");
  80. /* oli start */
  81.                 pTempBitmap = E_AllocBitMap(width, height, 8, E_PIXELMAP,pEgsScreen->Map->Flags, NULL);
  82.                 if (pTempBitmap)
  83.                 {
  84.                     CopyMemQuick(image->data, pTempBitmap->Typekey.PixelMap.Planes.Dest,width*height);
  85.                     EB_CopyBitMap(pTempBitmap, pEgsScreen->Map, src_x, src_y, width, height,dest_x, dest_y, 0L);
  86.                     E_DisposeBitMap(pTempBitmap);
  87.                 }
  88. /* oli end */
  89.                 break;
  90.             case PICASSO:
  91. fprintf(stderr,"Going to blit imagedata to Picasso\n");
  92.                 Forbid();
  93.                 ScreenToFront(picasso_scr);
  94.                 picasso_mem=LockVillageScreen(picasso_scr);
  95.                 blitrec.SrcPitch=picasso_scr->Width;    /* Width of source display */
  96.                 blitrec.DestPitch=picasso_scr->Width;    /* Width of destination display */
  97.                 blitrec.Width=width;                /* Width of rectangle box */
  98.                 blitrec.Height=height;                /* Height of rectangle box */
  99.                 blitrec.ROP=VIL_SRCCOPY;
  100.  
  101.                 blitrec.SrcAdr=(UBYTE *)image->data;
  102.                 blitrec.DestAdr=(UBYTE *)picasso_mem;
  103.                 VillageBlitCopy(picasso_scr,&blitrec);
  104.                 WaitVillageBlit();
  105.                 UnLockVillageScreen(picasso_scr);
  106.                 Permit();
  107.                 break;
  108.             default:
  109.                 break;
  110.         }
  111.     }
  112.     else if( image->depth == 16 )
  113.     {
  114.         /* Standard 16 Bit Bitmap (chunky pixels) */
  115.         switch (gfxcard)
  116.         {
  117.             case MERLIN:
  118. /*                hrWriteRectRGB(&hrh->BitMap,image->data,image->data,image->data,0,0,width,height,2,2*width);*/
  119.                 break;
  120.             case EGS:
  121.             case PICASSO:
  122.             default:
  123.                 break;
  124.         }
  125.     }
  126.     else if( image->depth >= 24 )
  127.     {
  128.         switch (gfxcard)
  129.         {
  130.             case MERLIN:
  131. /* Chunky data in the following format Alpha, Blue, Green, Red. */
  132. /* Merlin needs it in Red, Green, Blue, Alpha or ARGB, or all R, all G or all B */
  133.                 hrWriteRectRGB(&hrh->BitMap,image->data+3,image->data+2,image->data+1,0,0,width,height,4,4*width);
  134.                 break;
  135.             case EGS:
  136.             case PICASSO:
  137.             default:
  138.                 break;
  139.         }
  140.     }
  141. }
  142.  
  143.  
  144. XStoreColors(Display *theDisp,Colormap theCmap,XColor defs[], int xa_cmap_size)
  145. {
  146.     ULONG i;
  147.  
  148.     switch (gfxcard)
  149.     {
  150.         case AMIGA:
  151.             for(i=0;i<xa_cmap_size;i++)
  152.             {
  153.                 SetRGB32(vp,i,(ULONG )defs[i].red<<24,(ULONG )defs[i].green<<24,(ULONG )defs[i].blue<<24);
  154.             }
  155.             break;
  156.         case MERLIN:
  157.             for(i=0;i<xa_cmap_size;i++)
  158.             {
  159.                 hrSetRGB32(hrh,i,(ULONG )defs[i].red<<24,(ULONG )defs[i].green<<24,(ULONG )defs[i].blue<<24);/*MERLIN*/
  160.             }
  161.             break;
  162.         case EGS:
  163. /* Oli start */
  164.             for (i=0; i < xa_cmap_size; i++)
  165.             {
  166.                 E_SetRGB8(pEgsScreen, i, (UWORD)defs[i].red << 24,(UWORD)defs[i].green << 24, (UWORD)defs[i].blue << 24);
  167.             }
  168. /* Oli end */
  169.             break;
  170.         case PICASSO:
  171.             for (i=0; i < xa_cmap_size; i++)
  172.             {
  173.                 SETRGB(picasso_scr,i , (UWORD)defs[i].red << 24,(UWORD)defs[i].green << 24, (UWORD)defs[i].blue << 24);
  174.             }
  175.         default:
  176.             break;
  177.     }
  178. }
  179. /* array defs contains colors scaled to 16 bits. */
  180.